
circular_doublelink:     file format elf32-littlearm


Disassembly of section .init:

00010354 <_init>:
   10354:	e1a0c00d 	mov	ip, sp
   10358:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   1035c:	e24cb004 	sub	fp, ip, #4
   10360:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}

Disassembly of section .plt:

00010364 <putchar@plt-0x14>:
   10364:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
   10368:	e59fe004 	ldr	lr, [pc, #4]	; 10374 <_init+0x20>
   1036c:	e08fe00e 	add	lr, pc, lr
   10370:	e5bef008 	ldr	pc, [lr, #8]!
   10374:	000105b0 	.word	0x000105b0

00010378 <putchar@plt>:
   10378:	e28fc600 	add	ip, pc, #0, 12
   1037c:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10380:	e5bcf5b0 	ldr	pc, [ip, #1456]!	; 0x5b0

00010384 <printf@plt>:
   10384:	e28fc600 	add	ip, pc, #0, 12
   10388:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   1038c:	e5bcf5a8 	ldr	pc, [ip, #1448]!	; 0x5a8

00010390 <malloc@plt>:
   10390:	e28fc600 	add	ip, pc, #0, 12
   10394:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   10398:	e5bcf5a0 	ldr	pc, [ip, #1440]!	; 0x5a0

0001039c <abort@plt>:
   1039c:	e28fc600 	add	ip, pc, #0, 12
   103a0:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103a4:	e5bcf598 	ldr	pc, [ip, #1432]!	; 0x598

000103a8 <__deregister_frame_info@plt>:
   103a8:	e28fc600 	add	ip, pc, #0, 12
   103ac:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103b0:	e5bcf590 	ldr	pc, [ip, #1424]!	; 0x590

000103b4 <__uClibc_main@plt>:
   103b4:	e28fc600 	add	ip, pc, #0, 12
   103b8:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103bc:	e5bcf588 	ldr	pc, [ip, #1416]!	; 0x588

000103c0 <__register_frame_info@plt>:
   103c0:	e28fc600 	add	ip, pc, #0, 12
   103c4:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103c8:	e5bcf580 	ldr	pc, [ip, #1408]!	; 0x580

000103cc <free@plt>:
   103cc:	e28fc600 	add	ip, pc, #0, 12
   103d0:	e28cca10 	add	ip, ip, #16, 20	; 0x10000
   103d4:	e5bcf578 	ldr	pc, [ip, #1400]!	; 0x578

Disassembly of section .text:

000103d8 <_start>:
   103d8:	e3a0b000 	.word	0xe3a0b000
   103dc:	e3a0e000 	.word	0xe3a0e000
   103e0:	e49d1004 	.word	0xe49d1004
   103e4:	e1a0200d 	.word	0xe1a0200d
   103e8:	e52d2004 	.word	0xe52d2004
   103ec:	e52d0004 	.word	0xe52d0004
   103f0:	e59fc010 	.word	0xe59fc010
   103f4:	e52dc004 	.word	0xe52dc004
   103f8:	e59f000c 	.word	0xe59f000c
   103fc:	e59f300c 	.word	0xe59f300c
   10400:	eaffffeb 	.word	0xeaffffeb
   10404:	ebffffe4 	.word	0xebffffe4
   10408:	00010844 	.word	0x00010844
   1040c:	000107bc 	.word	0x000107bc
   10410:	00010354 	.word	0x00010354

00010414 <deregister_tm_clones>:
   10414:	e59f301c 	ldr	r3, [pc, #28]	; 10438 <deregister_tm_clones+0x24>
   10418:	e59f001c 	ldr	r0, [pc, #28]	; 1043c <deregister_tm_clones+0x28>
   1041c:	e0603003 	rsb	r3, r0, r3
   10420:	e3530006 	cmp	r3, #6
   10424:	912fff1e 	bxls	lr
   10428:	e59f3010 	ldr	r3, [pc, #16]	; 10440 <deregister_tm_clones+0x2c>
   1042c:	e3530000 	cmp	r3, #0
   10430:	012fff1e 	bxeq	lr
   10434:	e12fff13 	bx	r3
   10438:	0002095b 	.word	0x0002095b
   1043c:	00020958 	.word	0x00020958
   10440:	00000000 	.word	0x00000000

00010444 <register_tm_clones>:
   10444:	e59f1024 	ldr	r1, [pc, #36]	; 10470 <register_tm_clones+0x2c>
   10448:	e59f0024 	ldr	r0, [pc, #36]	; 10474 <register_tm_clones+0x30>
   1044c:	e0601001 	rsb	r1, r0, r1
   10450:	e1a01141 	asr	r1, r1, #2
   10454:	e0811fa1 	add	r1, r1, r1, lsr #31
   10458:	e1b010c1 	asrs	r1, r1, #1
   1045c:	012fff1e 	bxeq	lr
   10460:	e59f3010 	ldr	r3, [pc, #16]	; 10478 <register_tm_clones+0x34>
   10464:	e3530000 	cmp	r3, #0
   10468:	012fff1e 	bxeq	lr
   1046c:	e12fff13 	bx	r3
   10470:	00020958 	.word	0x00020958
   10474:	00020958 	.word	0x00020958
   10478:	00000000 	.word	0x00000000

0001047c <__do_global_dtors_aux>:
   1047c:	e92d4010 	push	{r4, lr}
   10480:	e59f402c 	ldr	r4, [pc, #44]	; 104b4 <__do_global_dtors_aux+0x38>
   10484:	e5d43000 	ldrb	r3, [r4]
   10488:	e3530000 	cmp	r3, #0
   1048c:	18bd8010 	popne	{r4, pc}
   10490:	ebffffdf 	bl	10414 <deregister_tm_clones>
   10494:	e59f301c 	ldr	r3, [pc, #28]	; 104b8 <__do_global_dtors_aux+0x3c>
   10498:	e3530000 	cmp	r3, #0
   1049c:	0a000001 	beq	104a8 <__do_global_dtors_aux+0x2c>
   104a0:	e59f0014 	ldr	r0, [pc, #20]	; 104bc <__do_global_dtors_aux+0x40>
   104a4:	ebffffbf 	bl	103a8 <__deregister_frame_info@plt>
   104a8:	e3a03001 	mov	r3, #1
   104ac:	e5c43000 	strb	r3, [r4]
   104b0:	e8bd8010 	pop	{r4, pc}
   104b4:	00020958 	.word	0x00020958
   104b8:	00000000 	.word	0x00000000
   104bc:	0001085c 	.word	0x0001085c

000104c0 <frame_dummy>:
   104c0:	e59f3040 	ldr	r3, [pc, #64]	; 10508 <frame_dummy+0x48>
   104c4:	e92d4010 	push	{r4, lr}
   104c8:	e3530000 	cmp	r3, #0
   104cc:	0a000002 	beq	104dc <frame_dummy+0x1c>
   104d0:	e59f1034 	ldr	r1, [pc, #52]	; 1050c <frame_dummy+0x4c>
   104d4:	e59f0034 	ldr	r0, [pc, #52]	; 10510 <frame_dummy+0x50>
   104d8:	ebffffb8 	bl	103c0 <__register_frame_info@plt>
   104dc:	e59f0030 	ldr	r0, [pc, #48]	; 10514 <frame_dummy+0x54>
   104e0:	e5903000 	ldr	r3, [r0]
   104e4:	e3530000 	cmp	r3, #0
   104e8:	1a000001 	bne	104f4 <frame_dummy+0x34>
   104ec:	e8bd4010 	pop	{r4, lr}
   104f0:	eaffffd3 	b	10444 <register_tm_clones>
   104f4:	e59f301c 	ldr	r3, [pc, #28]	; 10518 <frame_dummy+0x58>
   104f8:	e3530000 	cmp	r3, #0
   104fc:	0afffffa 	beq	104ec <frame_dummy+0x2c>
   10500:	e12fff33 	blx	r3
   10504:	eafffff8 	b	104ec <frame_dummy+0x2c>
   10508:	00000000 	.word	0x00000000
   1050c:	0002095c 	.word	0x0002095c
   10510:	0001085c 	.word	0x0001085c
   10514:	00020868 	.word	0x00020868
   10518:	00000000 	.word	0x00000000

0001051c <create_head>:
  struct list * prev;
  struct list * next;
};

struct list * create_head()
{
   1051c:	e92d4800 	push	{fp, lr}
   10520:	e28db004 	add	fp, sp, #4
   10524:	e24dd008 	sub	sp, sp, #8
  struct list * head;

  head = (struct list *) malloc (sizeof(struct list));
   10528:	e3a0000c 	mov	r0, #12
   1052c:	ebffff97 	bl	10390 <malloc@plt>
   10530:	e1a03000 	mov	r3, r0
   10534:	e50b3008 	str	r3, [fp, #-8]
  head->prev = head;
   10538:	e51b3008 	ldr	r3, [fp, #-8]
   1053c:	e51b2008 	ldr	r2, [fp, #-8]
   10540:	e5832004 	str	r2, [r3, #4]
  head->next = head;
   10544:	e51b3008 	ldr	r3, [fp, #-8]
   10548:	e51b2008 	ldr	r2, [fp, #-8]
   1054c:	e5832008 	str	r2, [r3, #8]

  return head;
   10550:	e51b3008 	ldr	r3, [fp, #-8]
}
   10554:	e1a00003 	mov	r0, r3
   10558:	e24bd004 	sub	sp, fp, #4
   1055c:	e8bd8800 	pop	{fp, pc}

00010560 <insert>:

int insert(struct list * head, int value)
{
   10560:	e92d4800 	push	{fp, lr}
   10564:	e28db004 	add	fp, sp, #4
   10568:	e24dd010 	sub	sp, sp, #16
   1056c:	e50b0010 	str	r0, [fp, #-16]
   10570:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src, * des;

  if (head == NULL)
   10574:	e51b3010 	ldr	r3, [fp, #-16]
   10578:	e3530000 	cmp	r3, #0
   1057c:	1a000001 	bne	10588 <insert+0x28>
    return 0;
   10580:	e3a03000 	mov	r3, #0
   10584:	ea000015 	b	105e0 <insert+0x80>

  src = head->next;
   10588:	e51b3010 	ldr	r3, [fp, #-16]
   1058c:	e5933008 	ldr	r3, [r3, #8]
   10590:	e50b3008 	str	r3, [fp, #-8]
  des = (struct list *) malloc (sizeof(struct list));
   10594:	e3a0000c 	mov	r0, #12
   10598:	ebffff7c 	bl	10390 <malloc@plt>
   1059c:	e1a03000 	mov	r3, r0
   105a0:	e50b300c 	str	r3, [fp, #-12]
  des->num = value;
   105a4:	e51b300c 	ldr	r3, [fp, #-12]
   105a8:	e51b2014 	ldr	r2, [fp, #-20]	; 0xffffffec
   105ac:	e5832000 	str	r2, [r3]

  des->next = src;
   105b0:	e51b300c 	ldr	r3, [fp, #-12]
   105b4:	e51b2008 	ldr	r2, [fp, #-8]
   105b8:	e5832008 	str	r2, [r3, #8]
  des->prev = head;
   105bc:	e51b300c 	ldr	r3, [fp, #-12]
   105c0:	e51b2010 	ldr	r2, [fp, #-16]
   105c4:	e5832004 	str	r2, [r3, #4]

  head->next = des;
   105c8:	e51b3010 	ldr	r3, [fp, #-16]
   105cc:	e51b200c 	ldr	r2, [fp, #-12]
   105d0:	e5832008 	str	r2, [r3, #8]
  src->prev = des;
   105d4:	e51b3008 	ldr	r3, [fp, #-8]
   105d8:	e51b200c 	ldr	r2, [fp, #-12]
   105dc:	e5832004 	str	r2, [r3, #4]
}
   105e0:	e1a00003 	mov	r0, r3
   105e4:	e24bd004 	sub	sp, fp, #4
   105e8:	e8bd8800 	pop	{fp, pc}

000105ec <display_next>:

void display_next(struct list * head)
{
   105ec:	e92d4800 	push	{fp, lr}
   105f0:	e28db004 	add	fp, sp, #4
   105f4:	e24dd010 	sub	sp, sp, #16
   105f8:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  src = head;
   105fc:	e51b3010 	ldr	r3, [fp, #-16]
   10600:	e50b3008 	str	r3, [fp, #-8]
  while (src->next != head) {
   10604:	ea000007 	b	10628 <display_next+0x3c>
    src = src->next;
   10608:	e51b3008 	ldr	r3, [fp, #-8]
   1060c:	e5933008 	ldr	r3, [r3, #8]
   10610:	e50b3008 	str	r3, [fp, #-8]
    printf(" %d ", src->num);
   10614:	e51b3008 	ldr	r3, [fp, #-8]
   10618:	e5933000 	ldr	r3, [r3]
   1061c:	e1a01003 	mov	r1, r3
   10620:	e59f0024 	ldr	r0, [pc, #36]	; 1064c <display_next+0x60>
   10624:	ebffff56 	bl	10384 <printf@plt>
void display_next(struct list * head)
{
  struct list * src;

  src = head;
  while (src->next != head) {
   10628:	e51b3008 	ldr	r3, [fp, #-8]
   1062c:	e5932008 	ldr	r2, [r3, #8]
   10630:	e51b3010 	ldr	r3, [fp, #-16]
   10634:	e1520003 	cmp	r2, r3
   10638:	1afffff2 	bne	10608 <display_next+0x1c>
    src = src->next;
    printf(" %d ", src->num);
  }
  printf("\n");
   1063c:	e3a0000a 	mov	r0, #10
   10640:	ebffff4c 	bl	10378 <putchar@plt>
}
   10644:	e24bd004 	sub	sp, fp, #4
   10648:	e8bd8800 	pop	{fp, pc}
   1064c:	00010854 	.word	0x00010854

00010650 <display_prev>:

void display_prev(struct list * head)
{
   10650:	e92d4800 	push	{fp, lr}
   10654:	e28db004 	add	fp, sp, #4
   10658:	e24dd010 	sub	sp, sp, #16
   1065c:	e50b0010 	str	r0, [fp, #-16]
  struct list * src;

  src = head;
   10660:	e51b3010 	ldr	r3, [fp, #-16]
   10664:	e50b3008 	str	r3, [fp, #-8]
  while (src->prev != head) {
   10668:	ea000007 	b	1068c <display_prev+0x3c>
    src = src->prev;
   1066c:	e51b3008 	ldr	r3, [fp, #-8]
   10670:	e5933004 	ldr	r3, [r3, #4]
   10674:	e50b3008 	str	r3, [fp, #-8]
    printf(" %d ", src->num);
   10678:	e51b3008 	ldr	r3, [fp, #-8]
   1067c:	e5933000 	ldr	r3, [r3]
   10680:	e1a01003 	mov	r1, r3
   10684:	e59f0024 	ldr	r0, [pc, #36]	; 106b0 <display_prev+0x60>
   10688:	ebffff3d 	bl	10384 <printf@plt>
void display_prev(struct list * head)
{
  struct list * src;

  src = head;
  while (src->prev != head) {
   1068c:	e51b3008 	ldr	r3, [fp, #-8]
   10690:	e5932004 	ldr	r2, [r3, #4]
   10694:	e51b3010 	ldr	r3, [fp, #-16]
   10698:	e1520003 	cmp	r2, r3
   1069c:	1afffff2 	bne	1066c <display_prev+0x1c>
    src = src->prev;
    printf(" %d ", src->num);
  }
  printf("\n");
   106a0:	e3a0000a 	mov	r0, #10
   106a4:	ebffff33 	bl	10378 <putchar@plt>
}
   106a8:	e24bd004 	sub	sp, fp, #4
   106ac:	e8bd8800 	pop	{fp, pc}
   106b0:	00010854 	.word	0x00010854

000106b4 <find>:

struct list * find(struct list * head, int value)
{
   106b4:	e52db004 	push	{fp}		; (str fp, [sp, #-4]!)
   106b8:	e28db000 	add	fp, sp, #0
   106bc:	e24dd014 	sub	sp, sp, #20
   106c0:	e50b0010 	str	r0, [fp, #-16]
   106c4:	e50b1014 	str	r1, [fp, #-20]	; 0xffffffec
  struct list * src;

  if (head->num == value)
   106c8:	e51b3010 	ldr	r3, [fp, #-16]
   106cc:	e5932000 	ldr	r2, [r3]
   106d0:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   106d4:	e1520003 	cmp	r2, r3
   106d8:	1a000001 	bne	106e4 <find+0x30>
    return head;
   106dc:	e51b3010 	ldr	r3, [fp, #-16]
   106e0:	ea000012 	b	10730 <find+0x7c>

  src = head->next;
   106e4:	e51b3010 	ldr	r3, [fp, #-16]
   106e8:	e5933008 	ldr	r3, [r3, #8]
   106ec:	e50b3008 	str	r3, [fp, #-8]
  while (src != head) {
   106f0:	ea000009 	b	1071c <find+0x68>
    if (src->num == value)
   106f4:	e51b3008 	ldr	r3, [fp, #-8]
   106f8:	e5932000 	ldr	r2, [r3]
   106fc:	e51b3014 	ldr	r3, [fp, #-20]	; 0xffffffec
   10700:	e1520003 	cmp	r2, r3
   10704:	1a000001 	bne	10710 <find+0x5c>
      return src;
   10708:	e51b3008 	ldr	r3, [fp, #-8]
   1070c:	ea000007 	b	10730 <find+0x7c>
    src = src->next;
   10710:	e51b3008 	ldr	r3, [fp, #-8]
   10714:	e5933008 	ldr	r3, [r3, #8]
   10718:	e50b3008 	str	r3, [fp, #-8]

  if (head->num == value)
    return head;

  src = head->next;
  while (src != head) {
   1071c:	e51b2008 	ldr	r2, [fp, #-8]
   10720:	e51b3010 	ldr	r3, [fp, #-16]
   10724:	e1520003 	cmp	r2, r3
   10728:	1afffff1 	bne	106f4 <find+0x40>
    if (src->num == value)
      return src;
    src = src->next;
  }
  
  return NULL;
   1072c:	e3a03000 	mov	r3, #0
}
   10730:	e1a00003 	mov	r0, r3
   10734:	e24bd000 	sub	sp, fp, #0
   10738:	e49db004 	pop	{fp}		; (ldr fp, [sp], #4)
   1073c:	e12fff1e 	bx	lr

00010740 <delete>:

void delete(struct list * head, int value)
{
   10740:	e92d4800 	push	{fp, lr}
   10744:	e28db004 	add	fp, sp, #4
   10748:	e24dd018 	sub	sp, sp, #24
   1074c:	e50b0018 	str	r0, [fp, #-24]	; 0xffffffe8
   10750:	e50b101c 	str	r1, [fp, #-28]	; 0xffffffe4
  struct list * src, * prev, * next;
  
  src = find(head, value);
   10754:	e51b101c 	ldr	r1, [fp, #-28]	; 0xffffffe4
   10758:	e51b0018 	ldr	r0, [fp, #-24]	; 0xffffffe8
   1075c:	ebffffd4 	bl	106b4 <find>
   10760:	e50b0008 	str	r0, [fp, #-8]
  if (src == NULL)
   10764:	e51b3008 	ldr	r3, [fp, #-8]
   10768:	e3530000 	cmp	r3, #0
   1076c:	1a000000 	bne	10774 <delete+0x34>
    return;
   10770:	ea00000f 	b	107b4 <delete+0x74>
  
  prev = src->prev;
   10774:	e51b3008 	ldr	r3, [fp, #-8]
   10778:	e5933004 	ldr	r3, [r3, #4]
   1077c:	e50b300c 	str	r3, [fp, #-12]
  next = src->next;
   10780:	e51b3008 	ldr	r3, [fp, #-8]
   10784:	e5933008 	ldr	r3, [r3, #8]
   10788:	e50b3010 	str	r3, [fp, #-16]

  prev->next = src->next;
   1078c:	e51b3008 	ldr	r3, [fp, #-8]
   10790:	e5932008 	ldr	r2, [r3, #8]
   10794:	e51b300c 	ldr	r3, [fp, #-12]
   10798:	e5832008 	str	r2, [r3, #8]
  next->prev = src->prev;
   1079c:	e51b3008 	ldr	r3, [fp, #-8]
   107a0:	e5932004 	ldr	r2, [r3, #4]
   107a4:	e51b3010 	ldr	r3, [fp, #-16]
   107a8:	e5832004 	str	r2, [r3, #4]

  free(src);
   107ac:	e51b0008 	ldr	r0, [fp, #-8]
   107b0:	ebffff05 	bl	103cc <free@plt>
}
   107b4:	e24bd004 	sub	sp, fp, #4
   107b8:	e8bd8800 	pop	{fp, pc}

000107bc <main>:

int main()
{
   107bc:	e92d4800 	push	{fp, lr}
   107c0:	e28db004 	add	fp, sp, #4
   107c4:	e24dd008 	sub	sp, sp, #8
  struct list * node;

  node = create_head();
   107c8:	ebffff53 	bl	1051c <create_head>
   107cc:	e50b0008 	str	r0, [fp, #-8]
  insert(node, 1);
   107d0:	e3a01001 	mov	r1, #1
   107d4:	e51b0008 	ldr	r0, [fp, #-8]
   107d8:	ebffff60 	bl	10560 <insert>
  insert(node, 2);
   107dc:	e3a01002 	mov	r1, #2
   107e0:	e51b0008 	ldr	r0, [fp, #-8]
   107e4:	ebffff5d 	bl	10560 <insert>
  insert(node, 3);
   107e8:	e3a01003 	mov	r1, #3
   107ec:	e51b0008 	ldr	r0, [fp, #-8]
   107f0:	ebffff5a 	bl	10560 <insert>
  insert(node, 4);
   107f4:	e3a01004 	mov	r1, #4
   107f8:	e51b0008 	ldr	r0, [fp, #-8]
   107fc:	ebffff57 	bl	10560 <insert>
  insert(node, 5);
   10800:	e3a01005 	mov	r1, #5
   10804:	e51b0008 	ldr	r0, [fp, #-8]
   10808:	ebffff54 	bl	10560 <insert>
  display_next(node);
   1080c:	e51b0008 	ldr	r0, [fp, #-8]
   10810:	ebffff75 	bl	105ec <display_next>
  display_prev(node);
   10814:	e51b0008 	ldr	r0, [fp, #-8]
   10818:	ebffff8c 	bl	10650 <display_prev>
  delete(node, 3);
   1081c:	e3a01003 	mov	r1, #3
   10820:	e51b0008 	ldr	r0, [fp, #-8]
   10824:	ebffffc5 	bl	10740 <delete>
  display_next(node);
   10828:	e51b0008 	ldr	r0, [fp, #-8]
   1082c:	ebffff6e 	bl	105ec <display_next>
  display_prev(node);
   10830:	e51b0008 	ldr	r0, [fp, #-8]
   10834:	ebffff85 	bl	10650 <display_prev>
  
}
   10838:	e1a00003 	mov	r0, r3
   1083c:	e24bd004 	sub	sp, fp, #4
   10840:	e8bd8800 	pop	{fp, pc}

Disassembly of section .fini:

00010844 <_fini>:
   10844:	e1a0c00d 	mov	ip, sp
   10848:	e92ddff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, ip, lr, pc}
   1084c:	e24cb004 	sub	fp, ip, #4
   10850:	e91baff0 	ldmdb	fp, {r4, r5, r6, r7, r8, r9, sl, fp, sp, pc}
